/**
 * @ClassName Test
 * @Description TODO
 * @Author 李明忠
 * @Date 2025/4/17 10:04
 * @Version 1.0
 */
public class Test {
    /**
     * String类型
     * @param args
     */
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "world";
        System.out.println(str1+" "+str2);//hello world
        // +号表示字符串拼接

        //1.int转为String类型
        int num = 10;
        //法一:
        String str3 = num + "";
        System.out.println(str3);//10
        //法二:
        String str4 = String.valueOf(num);//想转谁就用谁的方法
        //想转为String就调用String的方法
        System.out.println(str3);//10

        //2.String转为int类型
        String str5 = "123";
        //法一:
        int num2 = Integer.valueOf(str5);//底层调的是parseInt()
        System.out.println(num2);//123
        //法二:
        int num3 = Integer.parseInt(str5);
        System.out.println(num3);//123
    }
    /**
     * 类型提升
     * @param args
     */
    public static void main14(String[] args) {
        //1.int与long之间：int会被提升为long
        int a = 10;
        long b = 12L;
//        int c = a + b;//编译报错
        //原因:
        //int a + long b
        //首先int a==变为=>long a
        //再进行相加 long a + long b
        //结果为long类型,你使用int的c接受是不行的

        long d = a + b;//编译通过

        //2.
        double num = 10.0;
        double num1 = a + num;//原理和上面一样的

        //3.byte和byte
        byte num2 = 12;
        byte num3 = 12;
//        byte num4 = num2 + num3;//编译报错
        //原因:
        //byte 和 byte 都是相同类型, 但是出现编译报错.
        // 原因是, 虽然 num2 和 num3 都是 byte, 但是计算 num2 + num3
        // 会先将 num2和 num3 都提升成 int, 再进行计算,
        // 得到的结果也是 int, 这是赋给 num4, 就会出现上述错误.
        //由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据.
        // 为了硬件上实现方便, 诸如 byte 和 short
        //这种低于 4 个字节的类型, 会先提升成 int, 再参与计算.

        //正确的写法:
        int num5 = num2 + num3;//编译通过

    }
    /**
     * 强制类型转换
     * @param args
     */
    public static void main13(String[] args) {
        //
        int num = 10;
        byte num1 = (byte)num;//强制让int的num转为byte的num1

        double c = 14.5;
        int d = (int)c;//强制让double的c转为int的c

        //强转的风险
        int a = 128;
        byte b = (byte)a;//强转后b的值还是128么?

        System.out.println(b);//结果为 -128 这是典型的溢出
    }
    /**
     * 自动转换
     * @param args
     */
    public static void main12(String[] args) {
        //1.int自动变为byte和short
        //前提1：必须是常量表达（即可以在编译时确定值的）
        //补充：变量是在运行时确定的
        //前提2：整型字面量的值必须在byte和short范围内

        //合法案例：
        byte num1 = 20;//int类型在底层自动转为byte类型
        short num2 = 20;

        //不合法例子：
//        byte num3 = 320;//直接报错

        //2.小类型自动转为大类型
        int a = 4;
        double b = a;//编译通过

        float f = 12.2F;
        double d = f;//编译通过

    }
    /**
     * 类型转换
     * @param args
     */
    public static void main11(String[] args) {
        //数值型
        int a = 10;//整型
        double b = 20.0;//浮点型
        char c = 'c';//字符型

        //数值型之间转化
        //1.整型和浮点型
        b = a;//可以转换
        a = (int)b;//可以转换
        //2.整型和字符型
        a = c;//可以转换
        c = (char)a;//可以转换
        //2.字符型和浮点型
        b = c;//可以转换
        c = (char)b;//可以转换

        //布尔型
        boolean flag = true;
//
//        //数值型和布尔类型的准换
//        a = flag;//整型-布尔型报错
//        b = flag;//整型-布尔型报错
//        c = flag;//整型-布尔型报错
    }
    /**
     * boolean
     * @param args
     */
    public static void main10(String[] args) {
        //boolean只可能有两个值：true和false
        boolean flag = true;
        boolean flag1 = false;
        System.out.println(flag);//true
        System.out.println(flag1);//false

        //注意：Java中boolean就只有两个值：true false
        //Java不像c语言内样，Java没有0假 非零真的概念
//        boolean flag3 = 0;//报错
//        boolean flag4 = 1;//报错
    }
    /**
     * char
     * @param args
     */
    public static void main9(String[] args) {
        //1.定义
        char c = 'A';
        char ch = '中';
        char ch1 = '国';
        System.out.println(c);//A
        System.out.println(ch);//中
        System.out.println(ch1);//国
    }
    /**
     * float
     * @param args
     */
    public static void main8(String[] args) {
        //1.Java中小数字面默认是double类型
//        float a= 10.0;//直接报错 java: 不兼容的类型: 从double转换到float可能会有损失

        //2.解决办法就是：
        //只需要让float类型的值赋给float类型的变量a就好了
        //而Java中float类型的小数字面量需要加上F或f
        //eg: 10.0F 编译器就会知道你这个10.0就是float类型
        float a = 10.0F;
        System.out.println(a);//10.0

        //float的容量：使用float的包装类Float
        System.out.println(Float.MIN_VALUE);//1.4E-45
        System.out.println(Float.MAX_VALUE);//3.4028235E38
    }
    /**
     * double
     * @param args
     */
    public static void main7(String[] args) {
        //1.定义：
        double b = 12.2;
        //现象：存进去几位小数，输出时候就是几位
        System.out.println(b);//12.2

        //2.浮点数所存的数是有精度为题的
        //也就是说计算机内部无法准确存储小数
        double num = 1.1;
        System.out.println(num*num);//1.2100000000000002
        //为什么结果不是1.21？
        //而且为什么结果1.2100000000000002他会有很多的小数位？

        //答案如下：
        // 1.1 在二进制中无法精确表示
        // 十进制的 1.1 在二进制中是一个无限循环小数：
        //计算机无法准确的小数存储，他只能尽可能的给你
        //精确到很多位数，因此，结果才会有很多的小数位。

        //3.如果我想让他保留指定的小数位
        //那么可以通过c语言中的格式化输出printf
        System.out.printf("%.2f\n",num*num);//1.21


        //4.int/int
        int a = 1;
        int c = 2;
        System.out.println(a/c);//0
        //为什么结果不是0.5而是0？
        //原因是在Java中，int除以int仍为int
        //他会主动舍弃小数部分

        //如果你想得到0.5，则必须有其中一个是double或者两个都是double
        //方法一：两个都是double
        double a1 = 1.0;
        double c1 = 2.0;
        System.out.println(a1/c1);//0.5
        //为什么只显示 0.5 而不是 0.500000？
        //浮点数的默认格式化规则：
        //Java 的 System.out.println 在打印 double 值时，
        // 会尽可能以最简洁的方式输出，而不会显示无意义的尾随零。
        //0.5 和 0.500000 在数值上是完全相同的，
        // 但 0.5 更简洁，因此 Java 选择这种形式。

        //方法二：有一个是double
        double a2 = 1.0;
        int c2 = 2;
        System.out.println(a2/c2);//0.5

        //5.double的容量:使用double的包装类Double
        System.out.println(Double.MIN_VALUE);//4.9E-324
        System.out.println(Double.MAX_VALUE);//1.7976931348623157E308
    }
    /**
     * byte相关
     * @param args
     */
    public static void main6(String[] args) {
        byte a = 100;
        System.out.println(a);//100

        //byte的容量：使用byte的包装类Byte
        System.out.println(Byte.MIN_VALUE);//-128
        System.out.println(Byte.MAX_VALUE);//127
    }
    /**
     * short相关
     * @param args
     */
    public static void main5(String[] args) {
        short a = 10;
        System.out.println(a);//10

        //short的容量:使用Short包装类
        System.out.println(Short.MIN_VALUE);//-32768
        System.out.println(Short.MAX_VALUE);//32767
    }
    /**
     * long类型相关
     * @param args
     */
    public static void main4(String[] args) {
        //注意点一：
        long a = 100;//int 类型的100赋值给 long类型的a
        //其实这句代码是将int型100存入到了
        //long类型的变量a当中,原因是，在Java中，整型字面量默认是int型
        //如果想让long类型赋值给long类型那么就需要:在整型字面量后面+L或l

        //注意点二：
        long b = 100L;//long类型的100 赋值给 long类型的b
        System.out.println(b);//100

        //long的表示范围：使用long的包装类Long
        System.out.println(Long.MIN_VALUE);//-9223372036854775808
        System.out.println(Long.MAX_VALUE);//9223372036854775807
    }
    /**
     * int类型的使用
     * @param args
     */
    public static void main3(String[] args) {
        //方式一：在定义时给出始终
        int a = 4;
        System.out.println(a);//4

        //方式二：先定义后赋值
        int b;
        b = 10;
        System.out.println(b);//10

        //int类型所能表示的范围：记住21亿左右
        //使用的是int的包装类Integer，以后会学
        System.out.println(Integer.MIN_VALUE);//-2147483648
        System.out.println(Integer.MAX_VALUE);//2147483647

        //注意存储范围不能超过int所能表示的范围，否则编译器报错
//        int num = 1234567788991223;//编译报错：整数太大

        //局部变量必须赋初值
//        int c;
//        System.out.println(c);//编译报错：可能尚未初始化变量c

//        boolean flag;
//        System.out.println(flag);
    }

    /**
     * 变量的定义
     * @param args
     */
    public static void main2(String[] args) {
        int a = 10;
        double b = 1.2;
        boolean flag = true;
        System.out.println(a);//10
        System.out.println(b);//1.2
        System.out.println(flag);//true
    }

    /**
     * 字面量的介绍
     * @param args
     */
    public static void main1(String[] args) {
        //字面量（就是你写的形如以下的常量）
        System.out.println("hello world");//字符串常量
        System.out.println(10);//整形常量（没有小数点）
        System.out.println(2.5);//浮点常量
        System.out.println('A');//字符常量
        System.out.println(true);//布尔常量
    }
}
